home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 27 / CU Amiga Magazine's Super CD-ROM 27 (1998)(EMAP Images)(GB)[!][issue 1998-10].iso / CUCD / Programming / Mesa / src-glu / nurbs.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-08-02  |  20.7 KB  |  675 lines
  1. /* $Id: nurbs.c,v 1.11 1998/02/07 14:29:11 brianp Exp $ */
  2.  
  3. /*
  4.  * Mesa 3-D graphics library
  5.  * Version:  2.6
  6.  * Copyright (C) 1995-1997  Brian Paul
  7.  *
  8.  * This library is free software; you can redistribute it and/or
  9.  * modify it under the terms of the GNU Library General Public
  10.  * License as published by the Free Software Foundation; either
  11.  * version 2 of the License, or (at your option) any later version.
  12.  *
  13.  * This library is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16.  * Library General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU Library General Public
  19.  * License along with this library; if not, write to the Free
  20.  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  */
  22.  
  23.  
  24. /*
  25.  * nurbs.c
  26.  *
  27.  * Version 1.0  27 Jun 1998
  28.  * by Jarno van der Linden
  29.  * jarno@kcbbs.gen.nz
  30.  *
  31.  * File created from nurbs.c ver 1.11 and glu.h ver 1.9 using GenProtos
  32.  *
  33.  */
  34.  
  35.  
  36. /*
  37.  * NURBS implementation written by Bogdan Sikorski (bogdan@cira.it)
  38.  * See README2 for more info.
  39.  */
  40.  
  41. #ifdef PC_HEADER
  42. #include "all.h"
  43. #else
  44. #include <stdio.h>
  45. #include <stdlib.h>
  46. #include "gluP.h"
  47. #include "nurbs.h"
  48. #endif
  49.  
  50.  
  51. void
  52. call_user_error( GLUnurbsObj *nobj, GLenum error )
  53. {
  54.     nobj->error=error;
  55.     if(nobj->error_callback != NULL) {
  56.         (*(nobj->error_callback))(error);
  57.     }
  58.     else {
  59.        printf("NURBS error %d %s\n", error, gluErrorString(error) );
  60.     }
  61. }
  62.  
  63.  
  64.  
  65. __asm __saveds GLUnurbsObj * APIENTRY gluNewNurbsRenderer( void )
  66. {
  67.    GLUnurbsObj *n;
  68.    GLfloat tmp_viewport[4];
  69.    GLint i,j;
  70.  
  71.    n = (GLUnurbsObj *) malloc( sizeof(GLUnurbsObj) );
  72.    if (n) {
  73.       /* init */
  74.       n->culling=GL_FALSE;
  75.       n->nurbs_type=GLU_NURBS_NONE;
  76.       n->error=GLU_NO_ERROR;
  77.       n->error_callback=NULL;
  78.       n->auto_load_matrix=GL_TRUE;
  79.       n->sampling_tolerance=50.0;
  80.       n->parametric_tolerance=0.5;
  81.       n->u_step = n->v_step = 100;
  82.       n->sampling_method = GLU_PATH_LENGTH;
  83.       n->display_mode=GLU_FILL;
  84.       /* in case the user doesn't supply the sampling matrices */
  85.       /* set projection and modelview to identity */
  86.       for(i=0;i<4;i++)
  87.           for(j=0;j<4;j++)
  88.               if(i==j)
  89.               {
  90.                 n->sampling_matrices.model[i*4+j]=1.0;
  91.                 n->sampling_matrices.proj[i*4+j]=1.0;
  92.             }
  93.             else
  94.               {
  95.                 n->sampling_matrices.model[i*4+j]=0.0;
  96.                 n->sampling_matrices.proj[i*4+j]=0.0;
  97.             }
  98.       /* and set the viewport sampling matrix to current ciewport */
  99.       glGetFloatv(GL_VIEWPORT,tmp_viewport);
  100.       for(i=0;i<4;i++)
  101.           n->sampling_matrices.viewport[i]=tmp_viewport[i];
  102.       n->trim=NULL;
  103.    }
  104.    return n;
  105. }
  106.  
  107.  
  108.  
  109. __asm __saveds void APIENTRY gluDeleteNurbsRenderer( register __a0 GLUnurbsObj *nobj )
  110. {
  111.    if (nobj) {
  112.       free( nobj );
  113.    }
  114. }
  115.  
  116.  
  117.  
  118. __asm __saveds void APIENTRY gluLoadSamplingMatrices( register __a0 GLUnurbsObj *nobj,
  119.                                                       register __a1 const GLfloat modelMatrix[16],
  120.                                                       register __a2 const GLfloat projMatrix[16],
  121.                                                       register __a3 const GLint viewport[4] )
  122. {
  123.     GLint    i;
  124.  
  125.     for(i=0;i<16;i++)
  126.     {
  127.         nobj->sampling_matrices.model[i]=modelMatrix[i];
  128.         nobj->sampling_matrices.proj[i]=projMatrix[i];
  129.     }
  130.     for(i=0;i<4;i++)
  131.         nobj->sampling_matrices.viewport[i]=viewport[i];
  132. }
  133.  
  134.  
  135. __asm __saveds void APIENTRY gluNurbsProperty( register __a0 GLUnurbsObj *nobj, register __d0 GLenum property, register __fp0 GLfloat value )
  136. {
  137.    GLenum val;
  138.  
  139.    switch (property) {
  140.       case GLU_SAMPLING_TOLERANCE:
  141.            if(value <= 0.0)
  142.            {
  143.                call_user_error(nobj,GLU_INVALID_VALUE);
  144.                return;
  145.          }
  146.          nobj->sampling_tolerance=value;
  147.          break;
  148.       case GLU_PARAMETRIC_TOLERANCE:
  149.            if(value <= 0.0)
  150.            {
  151.                call_user_error(nobj,GLU_INVALID_VALUE);
  152.                return;
  153.          }
  154.          nobj->parametric_tolerance=value;
  155.          break;
  156.       case GLU_U_STEP:
  157.            if(value <= 0.0)
  158.            {
  159.                call_user_error(nobj,GLU_INVALID_VALUE);
  160.                return;
  161.          }
  162.          nobj->u_step=(GLint)value;
  163.          break;
  164.       case GLU_V_STEP:
  165.            if(value <= 0.0)
  166.            {
  167.                call_user_error(nobj,GLU_INVALID_VALUE);
  168.                return;
  169.          }
  170.          nobj->v_step=(GLint)value;
  171.          break;
  172.       case GLU_SAMPLING_METHOD:
  173.          val = (GLenum)value;
  174.          if(val!=GLU_PATH_LENGTH && val!=GLU_PARAMETRIC_ERROR && val!=GLU_DOMAIN_DISTANCE)
  175.          {
  176.              call_user_error(nobj,GLU_INVALID_ENUM);
  177.              return;
  178.          }
  179.          nobj->sampling_method=val;
  180.          break;
  181.       case GLU_DISPLAY_MODE:
  182.          val=(GLenum)value;
  183.          if(val!=GLU_FILL && val!=GLU_OUTLINE_POLYGON && val!=GLU_OUTLINE_PATCH)
  184.          {
  185.              call_user_error(nobj,GLU_INVALID_ENUM);
  186.              return;
  187.          }
  188.          if(nobj->nurbs_type==GLU_NURBS_CURVE)
  189.          {
  190.              call_user_error(nobj,GLU_NURBS_ERROR26);
  191.              return;
  192.          }
  193.          nobj->display_mode=val;
  194. if(val==GLU_OUTLINE_PATCH)
  195.     fprintf(stderr,"NURBS, for the moment, can display only in POLYGON mode\n");
  196.          break;
  197.       case GLU_CULLING:
  198.          val=(GLenum)value;
  199.          if(val!=GL_TRUE && val!=GL_FALSE)
  200.          {
  201.              call_user_error(nobj,GLU_INVALID_ENUM);
  202.              return;
  203.          }
  204.          nobj->culling = (GLboolean) value;
  205.          break;
  206.       case GLU_AUTO_LOAD_MATRIX:
  207.          val=(GLenum)value;
  208.          if(val!=GL_TRUE && val!=GL_FALSE)
  209.          {
  210.              call_user_error(nobj,GLU_INVALID_ENUM);
  211.              return;
  212.          }
  213.          nobj->auto_load_matrix = (GLboolean) value;
  214.          break;
  215.       default:
  216.          call_user_error(nobj,GLU_NURBS_ERROR26);
  217.    }
  218. }
  219.  
  220.  
  221. __asm __saveds void APIENTRY gluGetNurbsProperty( register __a0 GLUnurbsObj *nobj, register __d0 GLenum property, register __a1 GLfloat *value )
  222. {
  223.    switch (property) {
  224.       case GLU_SAMPLING_TOLERANCE:
  225.          *value = nobj->sampling_tolerance;
  226.          break;
  227.       case GLU_DISPLAY_MODE:
  228.          *value = (GLfloat) (GLint) nobj->display_mode;
  229.          break;
  230.       case GLU_CULLING:
  231.          *value = nobj->culling ? 1.0 : 0.0;
  232.          break;
  233.       case GLU_AUTO_LOAD_MATRIX:
  234.          *value = nobj->auto_load_matrix ? 1.0 : 0.0;
  235.          break;
  236.       default:
  237.          call_user_error(nobj,GLU_INVALID_ENUM);
  238.    }
  239. }
  240.  
  241.  
  242.  
  243. __asm __saveds void APIENTRY gluBeginCurve( register __a0 GLUnurbsObj *nobj )
  244. {
  245.     if(nobj->nurbs_type==GLU_NURBS_CURVE)
  246.     {
  247.         call_user_error(nobj,GLU_NURBS_ERROR6);
  248.         return;
  249.     }
  250.     nobj->nurbs_type=GLU_NURBS_CURVE;
  251.     nobj->curve.geom.type=GLU_INVALID_ENUM;
  252.     nobj->curve.color.type=GLU_INVALID_ENUM;
  253.     nobj->curve.texture.type=GLU_INVALID_ENUM;
  254.     nobj->curve.normal.type=GLU_INVALID_ENUM;
  255. }
  256.  
  257.  
  258. __asm __saveds void APIENTRY gluEndCurve( register __a0 GLUnurbsObj * nobj )
  259. {
  260.     if(nobj->nurbs_type==GLU_NURBS_NONE)
  261.     {
  262.         call_user_error(nobj,GLU_NURBS_ERROR7);
  263.         return;
  264.     }
  265.     if(nobj->curve.geom.type==GLU_INVALID_ENUM)
  266.     {
  267.         call_user_error(nobj,GLU_NURBS_ERROR8);
  268.         nobj->nurbs_type=GLU_NURBS_NONE;
  269.         return;
  270.     }
  271.     glPushAttrib( (GLbitfield) (GL_EVAL_BIT | GL_ENABLE_BIT) );
  272.     glDisable(GL_MAP1_VERTEX_3);
  273.     glDisable(GL_MAP1_VERTEX_4);
  274.     glDisable(GL_MAP1_INDEX);
  275.     glDisable(GL_MAP1_COLOR_4);
  276.     glDisable(GL_MAP1_NORMAL);
  277.     glDisable(GL_MAP1_TEXTURE_COORD_1);
  278.     glDisable(GL_MAP1_TEXTURE_COORD_2);
  279.     glDisable(GL_MAP1_TEXTURE_COORD_3);
  280.     glDisable(GL_MAP1_TEXTURE_COORD_4);
  281.     glDisable(GL_MAP2_VERTEX_3);
  282.     glDisable(GL_MAP2_VERTEX_4);
  283.     glDisable(GL_MAP2_INDEX);
  284.     glDisable(GL_MAP2_COLOR_4);
  285.     glDisable(GL_MAP2_NORMAL);
  286.     glDisable(GL_MAP2_TEXTURE_COORD_1);
  287.     glDisable(GL_MAP2_TEXTURE_COORD_2);
  288.     glDisable(GL_MAP2_TEXTURE_COORD_3);
  289.     glDisable(GL_MAP2_TEXTURE_COORD_4);
  290.     do_nurbs_curve(nobj);
  291.     glPopAttrib();
  292.     nobj->nurbs_type=GLU_NURBS_NONE;
  293. }
  294.  
  295.  
  296. __asm __saveds void APIENTRY gluNurbsCurve( register __a0 GLUnurbsObj *nobj, register __d0 GLint nknots, register __a1 GLfloat *knot,
  297.                                             register __d1 GLint stride, register __a2 GLfloat *ctlarray, register __d2 GLint order, register __d3 GLenum type )
  298. {
  299.     if(nobj->nurbs_type==GLU_NURBS_TRIM)
  300.     {
  301. #if 0
  302. /* TODO: NOT IMPLEMENTED YET */
  303.         nurbs_trim *ptr1;
  304.         trim_list *ptr2;
  305.  
  306.         if(type!=GLU_MAP1_TRIM_2 && type!=GLU_MAP1_TRIM_3)
  307.         {
  308.             call_user_error(nobj,GLU_NURBS_ERROR14);
  309.             return;
  310.         }
  311.         for(ptr1=nobj->trim;ptr1->next;ptr1=ptr1->next);
  312.         if(ptr1->trim_loop)
  313.         {
  314.             for(ptr2=ptr1->trim_loop;ptr2->next;ptr2=ptr2->next);
  315.             if((ptr2->next=(trim_list *)malloc(sizeof(trim_list)))==NULL)
  316.             {
  317.                 call_user_error(nobj,GLU_OUT_OF_MEMORY);
  318.                 return;
  319.             }
  320.             ptr2=ptr2->next;
  321.         }
  322.         else
  323.         {
  324.             if((ptr2=(trim_list *)malloc(sizeof(trim_list)))==NULL)
  325.             {
  326.                 call_user_error(nobj,GLU_OUT_OF_MEMORY);
  327.                 return;
  328.             }
  329.             ptr1->trim_loop=ptr2;
  330.         }
  331.         ptr2->trim_type=GLU_TRIM_NURBS;
  332.         ptr2->curve.nurbs_curve.knot_count=nknots;
  333.         ptr2->curve.nurbs_curve.knot=knot;
  334.         ptr2->curve.nurbs_curve.stride=stride;
  335.         ptr2->curve.nurbs_curve.ctrlarray=ctlarray;
  336.         ptr2->curve.nurbs_curve.order=order;
  337.         ptr2->curve.nurbs_curve.dim= (type==GLU_MAP1_TRIM_2 ? 2 : 3 );
  338.         ptr2->curve.nurbs_curve.type=type;
  339.         ptr2->next=NULL;
  340. #endif
  341.     }
  342.     else
  343.     {
  344.         if(type==GLU_MAP1_TRIM_2 || type==GLU_MAP1_TRIM_3)
  345.         {
  346.             call_user_error(nobj,GLU_NURBS_ERROR22);
  347.             return;
  348.         }
  349.         if(nobj->nurbs_type!=GLU_NURBS_CURVE)
  350.         {
  351.             call_user_error(nobj,GLU_NURBS_ERROR10);
  352.             return;
  353.         }
  354.         switch(type)
  355.         {
  356.             case GL_MAP1_VERTEX_3:
  357.             case GL_MAP1_VERTEX_4:
  358.                 if(nobj->curve.geom.type!=GLU_INVALID_ENUM)
  359.                 {
  360.                     call_user_error(nobj,GLU_NURBS_ERROR8);
  361.                     return;
  362.                 }
  363.                 nobj->curve.geom.type=type;
  364.                 nobj->curve.geom.knot_count=nknots;
  365.                 nobj->curve.geom.knot=knot;
  366.                 nobj->curve.geom.stride=stride;
  367.                 nobj->curve.geom.ctrlarray=ctlarray;
  368.                 nobj->curve.geom.order=order;
  369.                 break;
  370.             case GL_MAP1_INDEX:
  371.             case GL_MAP1_COLOR_4:
  372.                 nobj->curve.color.type=type;
  373.                 nobj->curve.color.knot_count=nknots;
  374.                 nobj->curve.color.knot=knot;
  375.                 nobj->curve.color.stride=stride;
  376.                 nobj->curve.color.ctrlarray=ctlarray;
  377.                 nobj->curve.color.order=order;
  378.                 break;
  379.             case GL_MAP1_NORMAL:
  380.                 nobj->curve.normal.type=type;
  381.                 nobj->curve.normal.knot_count=nknots;
  382.                 nobj->curve.normal.knot=knot;
  383.                 nobj->curve.normal.stride=stride;
  384.                 nobj->curve.normal.ctrlarray=ctlarray;
  385.                 nobj->curve.normal.order=order;
  386.                 break;
  387.             case GL_MAP1_TEXTURE_COORD_1:
  388.             case GL_MAP1_TEXTURE_COORD_2:
  389.             case GL_MAP1_TEXTURE_COORD_3:
  390.             case GL_MAP1_TEXTURE_COORD_4:
  391.                 nobj->curve.texture.type=type;
  392.                 nobj->curve.texture.knot_count=nknots;
  393.                 nobj->curve.texture.knot=knot;
  394.                 nobj->curve.texture.stride=stride;
  395.                 nobj->curve.texture.ctrlarray=ctlarray;
  396.                 nobj->curve.texture.order=order;
  397.                 break;
  398.             default:
  399.                  call_user_error(nobj,GLU_INVALID_ENUM);
  400.         }
  401.     }
  402. }
  403.  
  404.  
  405. __asm __saveds void APIENTRY gluBeginSurface( register __a0 GLUnurbsObj *nobj )
  406. {
  407.     switch(nobj->nurbs_type)
  408.     {
  409.         case GLU_NURBS_NONE:
  410.             nobj->nurbs_type=GLU_NURBS_SURFACE;
  411.             nobj->surface.geom.type=GLU_INVALID_ENUM;
  412.             nobj->surface.color.type=GLU_INVALID_ENUM;
  413.             nobj->surface.texture.type=GLU_INVALID_ENUM;
  414.             nobj->surface.normal.type=GLU_INVALID_ENUM;
  415.             break;
  416.         case GLU_NURBS_TRIM:
  417.             call_user_error(nobj,GLU_NURBS_ERROR16);
  418.             break;
  419.         case GLU_NURBS_SURFACE:
  420.         case GLU_NURBS_NO_TRIM:
  421.         case GLU_NURBS_TRIM_DONE:
  422.             call_user_error(nobj,GLU_NURBS_ERROR27);
  423.             break;
  424.         case GLU_NURBS_CURVE:
  425.             call_user_error(nobj,GLU_NURBS_ERROR6);
  426.             break;
  427.     }
  428. }
  429.  
  430.  
  431. __asm __saveds void APIENTRY gluEndSurface( register __a0 GLUnurbsObj * nobj )
  432. {
  433.     switch(nobj->nurbs_type)
  434.     {
  435.         case GLU_NURBS_NONE:
  436.             call_user_error(nobj,GLU_NURBS_ERROR13);
  437.             break;
  438.         case GLU_NURBS_TRIM:
  439.             call_user_error(nobj,GLU_NURBS_ERROR12);
  440.             break;
  441.         case GLU_NURBS_TRIM_DONE:
  442. /*            if(nobj->trim->trim_loop==NULL)
  443.             {
  444.                 call_user_error(nobj,GLU_NURBS_ERROR18);
  445.                 return;
  446.             }*/
  447.             /* no break - fallthrough */
  448.         case GLU_NURBS_NO_TRIM:
  449.             glPushAttrib( (GLbitfield)
  450.                 (GL_EVAL_BIT | GL_ENABLE_BIT | GL_POLYGON_BIT) );
  451.             glDisable(GL_MAP2_VERTEX_3);
  452.             glDisable(GL_MAP2_VERTEX_4);
  453.             glDisable(GL_MAP2_INDEX);
  454.             glDisable(GL_MAP2_COLOR_4);
  455.             glDisable(GL_MAP2_NORMAL);
  456.             glDisable(GL_MAP2_TEXTURE_COORD_1);
  457.             glDisable(GL_MAP2_TEXTURE_COORD_2);
  458.             glDisable(GL_MAP2_TEXTURE_COORD_3);
  459.             glDisable(GL_MAP2_TEXTURE_COORD_4);
  460. /*            glDisable(GL_MAP1_VERTEX_3);
  461.             glDisable(GL_MAP1_VERTEX_4);
  462.             glDisable(GL_MAP1_INDEX);
  463.             glDisable(GL_MAP1_COLOR_4);
  464.             glDisable(GL_MAP1_NORMAL);
  465.             glDisable(GL_MAP1_TEXTURE_COORD_1);
  466.             glDisable(GL_MAP1_TEXTURE_COORD_2);
  467.             glDisable(GL_MAP1_TEXTURE_COORD_3);
  468.             glDisable(GL_MAP1_TEXTURE_COORD_4);*/
  469.             do_nurbs_surface(nobj);
  470.             glPopAttrib();
  471.             break;
  472.         default:
  473.             call_user_error(nobj,GLU_NURBS_ERROR8);
  474.     }
  475.     nobj->nurbs_type=GLU_NURBS_NONE;
  476. }
  477.  
  478.  
  479. __asm __saveds void APIENTRY gluNurbsSurface( register __a0 GLUnurbsObj *nobj,
  480.                                               register __d0 GLint sknot_count, register __a1 GLfloat *sknot,
  481.                                               register __d1 GLint tknot_count, register __a2 GLfloat *tknot,
  482.                                               register __d2 GLint s_stride, register __d3 GLint t_stride,
  483.                                               register __a3 GLfloat *ctrlarray,
  484.                                               register __d4 GLint sorder, register __d5 GLint torder,
  485.                                               register __d6 GLenum type )
  486. {
  487.     if(nobj->nurbs_type==GLU_NURBS_NO_TRIM || nobj->nurbs_type==GLU_NURBS_TRIM ||
  488.         nobj->nurbs_type==GLU_NURBS_TRIM_DONE)
  489.     {
  490.         if(type==GL_MAP2_VERTEX_3 || type==GL_MAP2_VERTEX_4)
  491.         {
  492.             call_user_error(nobj,GLU_NURBS_ERROR8);
  493.             return;
  494.         }
  495.     }
  496.     else
  497.     if(nobj->nurbs_type!=GLU_NURBS_SURFACE)
  498.     {
  499.         call_user_error(nobj,GLU_NURBS_ERROR11);
  500.         return;
  501.     }
  502.     switch(type)
  503.     {
  504.         case GL_MAP2_VERTEX_3:
  505.         case GL_MAP2_VERTEX_4:
  506.             nobj->surface.geom.sknot_count=sknot_count;
  507.             nobj->surface.geom.sknot=sknot;
  508.             nobj->surface.geom.tknot_count=tknot_count;
  509.             nobj->surface.geom.tknot=tknot;
  510.             nobj->surface.geom.s_stride=s_stride;
  511.             nobj->surface.geom.t_stride=t_stride;
  512.             nobj->surface.geom.ctrlarray=ctrlarray;
  513.             nobj->surface.geom.sorder=sorder;
  514.             nobj->surface.geom.torder=torder;
  515.             nobj->surface.geom.type=type;
  516.             nobj->nurbs_type=GLU_NURBS_NO_TRIM;
  517.             break;
  518.         case GL_MAP2_INDEX:
  519.         case GL_MAP2_COLOR_4:
  520.             nobj->surface.color.sknot_count=sknot_count;
  521.             nobj->surface.color.sknot=sknot;
  522.             nobj->surface.color.tknot_count=tknot_count;
  523.             nobj->surface.color.tknot=tknot;
  524.             nobj->surface.color.s_stride=s_stride;
  525.             nobj->surface.color.t_stride=t_stride;
  526.             nobj->surface.color.ctrlarray=ctrlarray;
  527.             nobj->surface.color.sorder=sorder;
  528.             nobj->surface.color.torder=torder;
  529.             nobj->surface.color.type=type;
  530.             break;
  531.         case GL_MAP2_NORMAL:
  532.             nobj->surface.normal.sknot_count=sknot_count;
  533.             nobj->surface.normal.sknot=sknot;
  534.             nobj->surface.normal.tknot_count=tknot_count;
  535.             nobj->surface.normal.tknot=tknot;
  536.             nobj->surface.normal.s_stride=s_stride;
  537.             nobj->surface.normal.t_stride=t_stride;
  538.             nobj->surface.normal.ctrlarray=ctrlarray;
  539.             nobj->surface.normal.sorder=sorder;
  540.             nobj->surface.normal.torder=torder;
  541.             nobj->surface.normal.type=type;
  542.             break;
  543.         case GL_MAP2_TEXTURE_COORD_1:
  544.         case GL_MAP2_TEXTURE_COORD_2:
  545.         case GL_MAP2_TEXTURE_COORD_3:
  546.         case GL_MAP2_TEXTURE_COORD_4:
  547.             nobj->surface.texture.sknot_count=sknot_count;
  548.             nobj->surface.texture.sknot=sknot;
  549.             nobj->surface.texture.tknot_count=tknot_count;
  550.             nobj->surface.texture.tknot=tknot;
  551.             nobj->surface.texture.s_stride=s_stride;
  552.             nobj->surface.texture.t_stride=t_stride;
  553.             nobj->surface.texture.ctrlarray=ctrlarray;
  554.             nobj->surface.texture.sorder=sorder;
  555.             nobj->surface.texture.torder=torder;
  556.             nobj->surface.texture.type=type;
  557.             break;
  558.         default:
  559.              call_user_error(nobj,GLU_INVALID_ENUM);
  560.     }
  561. }
  562.  
  563.  
  564. __asm __saveds void APIENTRY gluNurbsCallback( register __a0 GLUnurbsObj *nobj, register __d0 GLenum which,
  565.                                                       register __a1 void (CALLBACK *fn)() )
  566. {
  567. #ifdef __CYGWIN32__
  568.     nobj->error_callback = (void(*)(GLenum))fn;
  569. #else
  570.     nobj->error_callback = (void(CALLBACK*)(GLenum))fn;
  571. #endif
  572.  
  573.     if(which!=GLU_ERROR)
  574.         call_user_error(nobj,GLU_INVALID_ENUM);
  575. }
  576.  
  577. __asm __saveds void APIENTRY gluBeginTrim( register __a0 GLUnurbsObj *nobj )
  578. {
  579. #if 0
  580.     nurbs_trim *ptr;
  581. #endif
  582.  
  583.     if(nobj->nurbs_type!=GLU_NURBS_TRIM_DONE)
  584.         if(nobj->nurbs_type!=GLU_NURBS_NO_TRIM)
  585.         {
  586.             call_user_error(nobj,GLU_NURBS_ERROR15);
  587.             return;
  588.         }
  589.     nobj->nurbs_type=GLU_NURBS_TRIM;
  590. fprintf(stderr,"NURBS - trimming not supported yet\n");
  591. #if 0
  592.     if((ptr=(nurbs_trim *)malloc(sizeof(nurbs_trim)))==NULL)
  593.     {
  594.         call_user_error(nobj,GLU_OUT_OF_MEMORY);
  595.         return;
  596.     }
  597.     if(nobj->trim)
  598.     {
  599.         nurbs_trim *tmp_ptr;
  600.  
  601.         for(tmp_ptr=nobj->trim;tmp_ptr->next;tmp_ptr=tmp_ptr->next);
  602.         tmp_ptr->next=ptr;
  603.     }
  604.     else
  605.         nobj->trim=ptr;
  606.     ptr->trim_loop=NULL;
  607.     ptr->segments=NULL;
  608.     ptr->next=NULL;
  609. #endif
  610. }
  611.  
  612. __asm __saveds void APIENTRY gluPwlCurve( register __a0 GLUnurbsObj *nobj, register __d0 GLint count,
  613.                                                  register __a1 GLfloat *array, register __d1 GLint stride, register __d2 GLenum type )
  614. {
  615. #if 0
  616.     nurbs_trim *ptr1;
  617.     trim_list *ptr2;
  618. #endif
  619.     if(nobj->nurbs_type==GLU_NURBS_CURVE)
  620.     {
  621.         call_user_error(nobj,GLU_NURBS_ERROR9);
  622.         return;
  623.     }
  624.     if(nobj->nurbs_type==GLU_NURBS_NONE)
  625.     {
  626.         call_user_error(nobj,GLU_NURBS_ERROR19);
  627.         return;
  628.     }
  629.     if(type!=GLU_MAP1_TRIM_2 && type!=GLU_MAP1_TRIM_3)
  630.     {
  631.         call_user_error(nobj,GLU_NURBS_ERROR14);
  632.         return;
  633.     }
  634. #if 0
  635.     for(ptr1=nobj->trim;ptr1->next;ptr1=ptr1->next);
  636.     if(ptr1->trim_loop)
  637.     {
  638.         for(ptr2=ptr1->trim_loop;ptr2->next;ptr2=ptr2->next);
  639.         if((ptr2->next=(trim_list *)malloc(sizeof(trim_list)))==NULL)
  640.         {
  641.             call_user_error(nobj,GLU_OUT_OF_MEMORY);
  642.             return;
  643.         }
  644.         ptr2=ptr2->next;
  645.     }
  646.     else
  647.     {
  648.         if((ptr2=(trim_list *)malloc(sizeof(trim_list)))==NULL)
  649.         {
  650.             call_user_error(nobj,GLU_OUT_OF_MEMORY);
  651.             return;
  652.         }
  653.         ptr1->trim_loop=ptr2;
  654.     }
  655.     ptr2->trim_type=GLU_TRIM_PWL;
  656.     ptr2->curve.pwl_curve.pt_count=count;
  657.     ptr2->curve.pwl_curve.ctrlarray=array;
  658.     ptr2->curve.pwl_curve.stride=stride;
  659.     ptr2->curve.pwl_curve.dim= (type==GLU_MAP1_TRIM_2 ? 2 : 3 );
  660.     ptr2->curve.pwl_curve.type=type;
  661.     ptr2->next=NULL;
  662. #endif
  663. }
  664.  
  665. __asm __saveds void APIENTRY gluEndTrim( register __a0 GLUnurbsObj *nobj )
  666. {
  667.     if(nobj->nurbs_type!=GLU_NURBS_TRIM)
  668.     {
  669.         call_user_error(nobj,GLU_NURBS_ERROR17);
  670.         return;
  671.     }
  672.     nobj->nurbs_type=GLU_NURBS_TRIM_DONE;
  673. }
  674.  
  675.